package com.goodwill.androidtest;

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;

public class Parser {
//    enum Op {
//        GT(">"), GE(">="), LT("<"), LE("<="), EQ("=="), AND("and"), OR("or"), CONTAINS("contains"), CONTAINS_NOT("containsnot");
//        private String operator;
//
//        Op(String operator) {
//            this.operator = operator;
//        }
//
//        public String getOperator() {
//            return operator;
//        }
//
//        public static Op getByOperator(String operator) {
//            if (operator == null || operator.length() == 0) {
//                return null;
//            }
//            for (Op op : Op.values()) {
//                if (op.getOperator().equalsIgnoreCase(operator)) {
//                    return op;
//                }
//            }
//            return null;
//        }
//    }
//
//    private static final List<String> operator = Lists.newArrayList(Op.GT.getOperator(), Op.GE.getOperator(), Op.LT.getOperator(), Op.LE.getOperator(), Op.EQ.getOperator(), Op.AND.getOperator(), Op.OR.getOperator(), Op.CONTAINS.getOperator(), Op.CONTAINS_NOT.getOperator());
//    private static Map<String, Integer> operatorMap = null;
//
//    static {
//        operatorMap = new HashMap<String, Integer>();
//        operatorMap.put("(", 1);
//        operatorMap.put(")", 1);
//        operatorMap.put("and", 11);
//        operatorMap.put("or", 12);
//        operatorMap.put("==", 7);
//        operatorMap.put("!=", 7);
//        operatorMap.put(">", 6);
//        operatorMap.put(">=", 6);
//        operatorMap.put("<", 6);
//        operatorMap.put("<=", 6);
//        operatorMap.put("contains", 14);
//        //operatorMap.put("containsNot",14);
//        operatorMap.put("containsnot", 14);
//    }
//
//    private ArrayList<String> getTokens(String pattern) {
//        String[] splitArr = pattern.split(" ");
//        ArrayList<String> tokens = new ArrayList<String>();
//        for (String split : splitArr) {
//            String trim = split.trim();
//            if (trim != null && trim.length() != 0) {
//                tokens.add(trim);
//            }
//        }
//        return tokens;
//    }
//
//    /**
//     * 计算表达式
//     *
//     * @return
//     * @throws Exception
//     */
//    public boolean calculate(String pattern, String log) throws Exception {
//        Stack<String> stack = new Stack<String>();
//        ArrayList<String> tokens = generateReversePolish(getTokens(pattern));
//        for (String token : tokens) {
//            //如果是操作数则入栈
//            if (!operatorMap.containsKey(token.toLowerCase())) {
//                stack.push(token);
//            } else {
//                String right = getValueFromContext(stack.pop(), log);
//                String left = getValueFromContext(stack.pop(), log);
//                stack.push(operate(left, right, token).toString());
//            }
//        }
//        if (stack.size() == 1) {
//            String valueString = stack.pop();
//            if (valueString.equalsIgnoreCase("true")) {
//                return true;
//            }
//        }
//        return false;
//    }
//
//    private String getValueFromContext(String variable, String log) {
//        if (!variable.contains("$")) {
//            return variable;
//        } else {
//            if (variable.equalsIgnoreCase("$")) {
//                return log;
//            } else if (variable.contains("$.")) {
//                //使用jsonpath解析
//                return String.valueOf(JSONPath.read(log, variable));
//            }
//        }
//        return null;
//    }
//
//
//    private ArrayList<String> generateReversePolish(ArrayList<String> tokens) throws Exception {
//        //运算符stack， 和 操作数stack
//        Stack<String> operatorStack = new Stack<String>();
//        Stack<String> numberStack = new Stack<String>();
//        for (String token : tokens) {
//            //如果是操作数，直接插入到操作数stack
//            if (!operatorMap.containsKey(token.toLowerCase())) {
//                numberStack.push(token);
//            } else {
//                if (operatorStack.empty()) {
//                    operatorStack.push(token);
//                } else {
//                    //如果是右括号 则要找到左括号 并且一次入栈到 操作数栈
//                    if (token.equals(")")) {
//                        String popToken = null;
//                        try {
//                            while (!(popToken = operatorStack.pop()).equals("(")) {
//                                numberStack.push(popToken);
//                            }
//                            continue;
//                        } catch (EmptyStackException e) {
//                            throw new Exception("invalid expression:  '", e);
//                        }
//                    }
//                    String preOperator = operatorStack.peek();
//                    //如果之前的操作符是（ ，则不用比较优先级 当前操作符直接入栈
//                    if (preOperator.equals("(")) {
//                        operatorStack.push(token);
//                    }
//                    //比较操作符优先级， 如果该操作符优先级大于等于 ， 则直接入栈
//                    else if (operatorMap.get(token) <= operatorMap.get(preOperator)) {
//                        operatorStack.push(token);
//                    }
//                    //如果该操作符优先级 小于， 则在将该操作符如栈之前 要把栈顶操作符 弹出 插入 操作数栈
//                    else {
//                        numberStack.push(operatorStack.pop());
//                        operatorStack.push(token);
//                    }
//                }
//            }
//        }
//        while (!operatorStack.empty()) {
//            numberStack.push(operatorStack.pop());
//        }
//        ArrayList<String> resArrayList = new ArrayList<String>();
//        String[] array = numberStack.toArray(new String[]{});
//        for (int i = 0; i < array.length; i++) {
//            resArrayList.add(array[i]);
//        }
//        return resArrayList;
//    }

//    private Boolean operate(String left, String right, String op) {
//        Op operator = Op.getByOperator(op);
//        if (operator == null) {
//            System.out.println("未知的操作 op = " + op);
//            return false;
//        }
//        Double leftNum = null;
//        Double rightNum = null;
//        switch (operator) {
//            case GT:
//                leftNum = Double.valueOf(left);
//                rightNum = Double.valueOf(right);
//                return leftNum > rightNum;
//            case GE:
//                leftNum = Double.valueOf(left);
//                rightNum = Double.valueOf(right);
//                return leftNum >= rightNum;
//            case LT:
//                leftNum = Double.valueOf(left);
//                rightNum = Double.valueOf(right);
//                return leftNum < rightNum;
//            case LE:
//                leftNum = Double.valueOf(left);
//                rightNum = Double.valueOf(right);
//                return leftNum <= rightNum;
//            case EQ:
//                return left.equals(right);
//            case AND:
//                if (!left.equals("true")) {
//                    return false;
//                }
//                if (!right.equals("true")) {
//                    return false;
//                }
//                return true;
//            case OR:
//                if (left.equals("true")) {
//                    return true;
//                }
//                if (right.equals("true")) {
//                    return true;
//                }
//                return false;
//            case CONTAINS:
//                if (left == null || right == null) {
//                    return false;
//                }
//                return left.contains(right);
//            case CONTAINS_NOT:
//                if (left == null || right == null) {
//                    return false;
//                }
//                return !left.contains(right);
//            default:
//                return false;
//        }
//    }
}
